#ifndef _NR_H_
#define _NR_H_

/************************************************************************/
/* Numeric recipe function definitions                                  */
/************************************************************************/
#define ANSI 1

#ifdef __cplusplus
extern "C" {
#endif

#ifndef _FCOMPLEX_DECLARE_T_
	typedef struct FCOMPLEX {
		float r,i;
	} fcomplex;
#define _FCOMPLEX_DECLARE_T_
#endif /* _FCOMPLEX_DECLARE_T_ */

#ifndef _ARITHCODE_DECLARE_T_
	typedef struct {
		unsigned long *ilob,*iupb,*ncumfq,jdif,nc,minint,nch,ncum,nrad;
	} arithcode;
#define _ARITHCODE_DECLARE_T_
#endif /* _ARITHCODE_DECLARE_T_ */

#ifndef _HUFFCODE_DECLARE_T_
	typedef struct {
		unsigned long *icod,*ncod,*left,*right,nch,nodemax;
	} huffcode;
#define _HUFFCODE_DECLARE_T_
#endif /* _HUFFCODE_DECLARE_T_ */

#include <stdio.h>

#if defined(__STDC__) || defined(ANSI) || defined(NRANSI) /* ANSI */

	void addint(double **uf, double **uc, double **res, int nf);
	void airy(float x, float *ai, float *bi, float *aip, float *bip);
	void amebsa(float **p, float y[], int ndim, float pb[], float *yb,
				float ftol, float (*funk)(float []), int *iter, float temptr);
	void amoeba(float **p, float y[], int ndim, float ftol,
				float (*funk)(float []), int *iter);
	float amotry(float **p, float y[], float psum[], int ndim,
				 float (*funk)(float []), int ihi, float fac);
	float amotsa(float **p, float y[], float psum[], int ndim, float pb[],
				 float *yb, float (*funk)(float []), int ihi, float *yhi, float fac);
	void anneal(float x[], float y[], int iorder[], int ncity);
	double anorm2(double **a, int n);
	void arcmak(unsigned long nfreq[], unsigned long nchh, unsigned long nradd,
				arithcode *acode);
	void arcode(unsigned long *ich, unsigned char **codep, unsigned long *lcode,
				unsigned long *lcd, int isign, arithcode *acode);
	void arcsum(unsigned long iin[], unsigned long iout[], unsigned long ja,
				int nwk, unsigned long nrad, unsigned long nc);
	void asolve(unsigned long n, double b[], double x[], int itrnsp);
	void atimes(unsigned long n, double x[], double r[], int itrnsp);
	void avevar(float data[], unsigned long n, float *ave, float *var);
	void balanc(float **a, int n);
	void banbks(float **a, unsigned long n, int m1, int m2, float **al,
				unsigned long indx[], float b[]);
	void bandec(float **a, unsigned long n, int m1, int m2, float **al,
				unsigned long indx[], float *d);
	void banmul(float **a, unsigned long n, int m1, int m2, float x[], float b[]);
	void bcucof(float y[], float y1[], float y2[], float y12[], float d1,
				float d2, float **c);
	void bcuint(float y[], float y1[], float y2[], float y12[],
				float x1l, float x1u, float x2l, float x2u, float x1,
				float x2, float *ansy, float *ansy1, float *ansy2);
	void beschb(double x, double *gam1, double *gam2, double *gampl,
				double *gammi);
	float bessi(int n, float x);
	float bessi0(float x);
	float bessi1(float x);
	void bessik(float x, float xnu, float *ri, float *rk, float *rip,
				float *rkp);
	float bessj(int n, float x);
	float bessj0(float x);
	float bessj1(float x);
	void bessjy(float x, float xnu, float *rj, float *ry, float *rjp,
				float *ryp);
	float bessk(int n, float x);
	float bessk0(float x);
	float bessk1(float x);
	float bessy(int n, float x);
	float bessy0(float x);
	float bessy1(float x);
	float beta(float z, float w);
	float betacf(float a, float b, float x);
	float betai(float a, float b, float x);
	float bico(int n, int k);
	void bksub(int ne, int nb, int jf, int k1, int k2, float ***c);
	float bnldev(float pp, int n, long *idum);
	float brent(float ax, float bx, float cx,
				float (*f)(float), float tol, float *xmin);
	void broydn(float x[], int n, int *check,
				void (*vecfunc)(int, float [], float []));
	void bsstep(float y[], float dydx[], int nv, float *xx, float htry,
				float eps, float yscal[], float *hdid, float *hnext,
				void (*derivs)(float, float [], float []));
	void caldat(long julian, int *mm, int *id, int *iyyy);
	void chder(float a, float b, float c[], float cder[], int n);
	float chebev(float a, float b, float c[], int m, float x);
	void chebft(float a, float b, float c[], int n, float (*func)(float));
	void chebpc(float c[], float d[], int n);
	void chint(float a, float b, float c[], float cint[], int n);
	float chixy(float bang);
	void choldc(float **a, int n, float p[]);
	void cholsl(float **a, int n, float p[], float b[], float x[]);
	void chsone(float bins[], float ebins[], int nbins, int knstrn,
				float *df, float *chsq, float *prob);
	void chstwo(float bins1[], float bins2[], int nbins, int knstrn,
				float *df, float *chsq, float *prob);
	void cisi(float x, float *ci, float *si);
	void cntab1(int **nn, int ni, int nj, float *chisq,
				float *df, float *prob, float *cramrv, float *ccc);
	void cntab2(int **nn, int ni, int nj, float *h, float *hx, float *hy,
				float *hygx, float *hxgy, float *uygx, float *uxgy, float *uxy);
	void convlv(float data[], unsigned long n, float respns[], unsigned long m,
				int isign, float ans[]);
	void copy(double **aout, double **ain, int n);
	void correl(float data1[], float data2[], unsigned long n, float ans[]);
	void cosft(float y[], int n, int isign);
	void cosft1(float y[], int n);
	void cosft2(float y[], int n, int isign);
	void covsrt(float **covar, int ma, int ia[], int mfit);
	void crank(unsigned long n, float w[], float *s);
	void cyclic(float a[], float b[], float c[], float alpha, float beta,
				float r[], float x[], unsigned long n);
	void daub4(float a[], unsigned long n, int isign);
	float dawson(float x);
	float dbrent(float ax, float bx, float cx,
				 float (*f)(float), float (*df)(float), float tol, float *xmin);
	void ddpoly(float c[], int nc, float x, float pd[], int nd);
	int decchk(char string[], int n, char *ch);
	void derivs(float x, float y[], float dydx[]);
	float df1dim(float x);
	void dfour1(double data[], unsigned long nn, int isign);
	void dfpmin(float p[], int n, float gtol, int *iter, float *fret,
				float (*func)(float []), void (*dfunc)(float [], float []));
	float dfridr(float (*func)(float), float x, float h, float *err);
	void dftcor(float w, float delta, float a, float b, float endpts[],
				float *corre, float *corim, float *corfac);
	void dftint(float (*func)(float), float a, float b, float w,
				float *cosint, float *sinint);
	void difeq(int k, int k1, int k2, int jsf, int is1, int isf,
			   int indexv[], int ne, float **s, float **y);
	void dlinmin(float p[], float xi[], int n, float *fret,
				 float (*func)(float []), void (*dfunc)(float [], float[]));
	double dpythag(double a, double b);
	void drealft(double data[], unsigned long n, int isign);
	void dsprsax(double sa[], unsigned long ija[], double x[], double b[],
				 unsigned long n);
	void dsprstx(double sa[], unsigned long ija[], double x[], double b[],
				 unsigned long n);
	void dsvbksb(double **u, double w[], double **v, int m, int n, double b[],
				 double x[]);
	void dsvdcmp(double **a, int m, int n, double w[], double **v);
	void eclass(int nf[], int n, int lista[], int listb[], int m);
	void eclazz(int nf[], int n, int (*equiv)(int, int));
	float ei(float x);
	void eigsrt(float d[], float **v, int n);
	float elle(float phi, float ak);
	float ellf(float phi, float ak);
	float ellpi(float phi, float en, float ak);
	void elmhes(float **a, int n);
	float erfcc(float x);
	float ur_erff(float x);
	float erffc(float x);
	void eulsum(float *sum, float term, int jterm, float wksp[]);
	float evlmem(float fdt, float d[], int m, float xms);
	float expdev(long *idum);
	float expint(int n, float x);
	float f1(float x);
	float f1dim(float x);
	float f2(float y);
	float f3(float z);
	float factln(int n);
	float factrl(int n);
	void fasper(float x[], float y[], unsigned long n, float ofac, float hifac,
				float wk1[], float wk2[], unsigned long nwk, unsigned long *nout,
				unsigned long *jmax, float *prob);
	void fdjac(int n, float x[], float fvec[], float **df,
			   void (*vecfunc)(int, float [], float []));
	void fgauss(float x, float a[], float *y, float dyda[], int na);
	void fill0(double **u, int n);
	void fit(float x[], float y[], int ndata, float sig[], int mwt,
			 float *a, float *b, float *siga, float *sigb, float *chi2, float *q);
	void fitexy(float x[], float y[], int ndat, float sigx[], float sigy[],
				float *a, float *b, float *siga, float *sigb, float *chi2, float *q);
	void fixrts(float d[], int m);
	void fleg(float x, float pl[], int nl);
	void flmoon(int n, int nph, long *jd, float *frac);
	float nr_fmin(float x[]);
	void four1(float data[], unsigned long nn, int isign);
	void fourew(FILE *file[5], int *na, int *nb, int *nc, int *nd);
	void fourfs(FILE *file[5], unsigned long nn[], int ndim, int isign);
	void fourn(float data[], unsigned long nn[], int ndim, int isign);
	void fpoly(float x, float p[], int np);
	void fred2(int n, float a, float b, float t[], float f[], float w[],
			   float (*g)(float), float (*ak)(float, float));
	float fredin(float x, int n, float a, float b, float t[], float f[], float w[],
				 float (*g)(float), float (*ak)(float, float));
	void frenel(float x, float *s, float *c);
	void frprmn(float p[], int n, float ftol, int *iter, float *fret,
				float (*func)(float []), void (*dfunc)(float [], float []));
	void ftest(float data1[], unsigned long n1, float data2[], unsigned long n2,
			   float *f, float *prob);
	float gamdev(int ia, long *idum);
	float gammln(float xx);
	float gammp(float a, float x);
	float gammq(float a, float x);
	float gasdev(long *idum);
	void gaucof(int n, float a[], float b[], float amu0, float x[], float w[]);
	void gauher(float x[], float w[], int n);
	void gaujac(float x[], float w[], int n, float alf, float bet);
	void gaulag(float x[], float w[], int n, float alf);
	void gauleg(float x1, float x2, float x[], float w[], int n);
	void gaussj(float **a, int n, float **b, int m);
	void gcf(float *gammcf, float a, float x, float *gln);
	float golden(float ax, float bx, float cx, float (*f)(float), float tol,
				 float *xmin);
	void gser(float *gamser, float a, float x, float *gln);
	void hpsel(unsigned long m, unsigned long n, float arr[], float heap[]);
	void hpsort(unsigned long n, float ra[]);
	void hqr(float **a, int n, float wr[], float wi[]);
	void hufapp(unsigned long index[], unsigned long nprob[], unsigned long n,
				unsigned long i);
	void hufdec(unsigned long *ich, unsigned char *code, unsigned long lcode,
				unsigned long *nb, huffcode *hcode);
	void hufenc(unsigned long ich, unsigned char **codep, unsigned long *lcode,
				unsigned long *nb, huffcode *hcode);
	void hufmak(unsigned long nfreq[], unsigned long nchin, unsigned long *ilong,
				unsigned long *nlong, huffcode *hcode);
	void hunt(float xx[], unsigned long n, float x, unsigned long *jlo);
	void hypdrv(float s, float yy[], float dyyds[]);
	fcomplex hypgeo(fcomplex a, fcomplex b, fcomplex c, fcomplex z);
	void hypser(fcomplex a, fcomplex b, fcomplex c, fcomplex z,
				fcomplex *series, fcomplex *deriv);
	unsigned short icrc(unsigned short crc, unsigned char *bufptr,
						unsigned long len, short jinit, int jrev);
	unsigned short icrc1(unsigned short crc, unsigned char onech);
	unsigned long igray(unsigned long n, int is);
	void iindexx(unsigned long n, long arr[], unsigned long indx[]);
	void indexx(unsigned long n, float arr[], unsigned long indx[]);
	void interp(double **uf, double **uc, int nf);
	int irbit1(unsigned long *iseed);
	int irbit2(unsigned long *iseed);
	void jacobi(float **a, int n, float d[], float **v, int *nrot);
	void jacobn(float x, float y[], float dfdx[], float **dfdy, int n);
	long julday(int mm, int id, int iyyy);
	void kendl1(float data1[], float data2[], unsigned long n, float *tau, float *z,
				float *prob);
	void kendl2(float **tab, int i, int j, float *tau, float *z, float *prob);
	void kermom(double w[], double y, int m);
	void ks2d1s(float x1[], float y1[], unsigned long n1,
				void (*quadvl)(float, float, float *, float *, float *, float *),
				float *d1, float *prob);
	void ks2d2s(float x1[], float y1[], unsigned long n1, float x2[], float y2[],
				unsigned long n2, float *d, float *prob);
	void ksone(float data[], unsigned long n, float (*func)(float), float *d,
			   float *prob);
	void kstwo(float data1[], unsigned long n1, float data2[], unsigned long n2,
			   float *d, float *prob);
	void laguer(fcomplex a[], int m, fcomplex *x, int *its);
	void lfit(float x[], float y[], float sig[], int ndat, float a[], int ia[],
			  int ma, float **covar, float *chisq, void (*funcs)(float, float [], int));
	void linbcg(unsigned long n, double b[], double x[], int itol, double tol,
				int itmax, int *iter, double *err);
	void linmin(float p[], float xi[], int n, float *fret,
				float (*func)(float []));
	void lnsrch(int n, float xold[], float fold, float g[], float p[], float x[],
				float *f, float stpmax, int *check, float (*func)(float []));
	void load(float x1, float v[], float y[]);
	void load1(float x1, float v1[], float y[]);
	void load2(float x2, float v2[], float y[]);
	void locate(float xx[], unsigned long n, float x, unsigned long *j);
	void lop(double **out, double **u, int n);
	void lubksb(float **a, int n, int *indx, float b[]);
	void ludcmp(float **a, int n, int *indx, float *d);
	void machar(int *ibeta, int *it, int *irnd, int *ngrd,
				int *machep, int *negep, int *iexp, int *minexp, int *maxexp,
				float *eps, float *epsneg, float *xmin, float *xmax);
	void matadd(double **a, double **b, double **c, int n);
	void matsub(double **a, double **b, double **c, int n);
	void medfit(float x[], float y[], int ndata, float *a, float *b, float *abdev);
	void memcof(float data[], int n, int m, float *xms, float d[]);
	int metrop(float de, float t);
	void mgfas(double **u, int n, int maxcyc);
	void mglin(double **u, int n, int ncycle);
	float midexp(float (*funk)(float), float aa, float bb, int n);
	float midinf(float (*funk)(float), float aa, float bb, int n);
	float midpnt(float (*func)(float), float a, float b, int n);
	float midsql(float (*funk)(float), float aa, float bb, int n);
	float midsqu(float (*funk)(float), float aa, float bb, int n);
	void miser(float (*func)(float []), float regn[], int ndim, unsigned long npts,
			   float dith, float *ave, float *var);
	void mmid(float y[], float dydx[], int nvar, float xs, float htot,
			  int nstep, float yout[], void (*derivs)(float, float[], float[]));
	void mnbrak(float *ax, float *bx, float *cx, float *fa, float *fb,
				float *fc, float (*func)(float));
	void mnewt(int ntrial, float x[], int n, float tolx, float tolf);
	void moment(float data[], int n, float *ave, float *adev, float *sdev,
				float *var, float *skew, float *curt);
	void mp2dfr(unsigned char a[], unsigned char s[], int n, int *m);
	void mpadd(unsigned char w[], unsigned char u[], unsigned char v[], int n);
	void mpdiv(unsigned char q[], unsigned char r[], unsigned char u[],
			   unsigned char v[], int n, int m);
	void mpinv(unsigned char u[], unsigned char v[], int n, int m);
	void mplsh(unsigned char u[], int n);
	void mpmov(unsigned char u[], unsigned char v[], int n);
	void mpmul(unsigned char w[], unsigned char u[], unsigned char v[], int n,
			   int m);
	void mpneg(unsigned char u[], int n);
	void mppi(int n);
	void mprove(float **a, float **alud, int n, int indx[], float b[],
				float x[]);
	void mpsad(unsigned char w[], unsigned char u[], int n, int iv);
	void mpsdv(unsigned char w[], unsigned char u[], int n, int iv, int *ir);
	void mpsmu(unsigned char w[], unsigned char u[], int n, int iv);
	void mpsqrt(unsigned char w[], unsigned char u[], unsigned char v[], int n,
				int m);
	void mpsub(int *is, unsigned char w[], unsigned char u[], unsigned char v[],
			   int n);
	void mrqcof(float x[], float y[], float sig[], int ndata, float a[],
				int ia[], int ma, float **alpha, float beta[], float *chisq,
				void (*funcs)(float, float [], float *, float [], int));
	void mrqmin(float x[], float y[], float sig[], int ndata, float a[],
				int ia[], int ma, float **covar, float **alpha, float *chisq,
				void (*funcs)(float, float [], float *, float [], int), float *alamda);
	void newt(float x[], int n, int *check,
			  void (*vecfunc)(int, float [], float []));
	void odeint(float ystart[], int nvar, float x1, float x2,
				float eps, float h1, float hmin, int *nok, int *nbad,
				void (*derivs)(float, float [], float []),
				void (*rkqs)(float [], float [], int, float *, float, float,
							 float [], float *, float *, void (*)(float, float [], float [])));
	void orthog(int n, float anu[], float alpha[], float beta[], float a[],
				float b[]);
	void pade(double cof[], int n, float *resid);
	void pccheb(float d[], float c[], int n);
	void pcshft(float a, float b, float d[], int n);
	void pearsn(float x[], float y[], unsigned long n, float *r, float *prob,
				float *z);
	void period(float x[], float y[], int n, float ofac, float hifac,
				float px[], float py[], int np, int *nout, int *jmax, float *prob);
	void piksr2(int n, float arr[], float brr[]);
	void piksrt(int n, float arr[]);
	void pinvs(int ie1, int ie2, int je1, int jsf, int jc1, int k,
			   float ***c, float **s);
	float plgndr(int l, int m, float x);
	float poidev(float xm, long *idum);
	void polcoe(float x[], float y[], int n, float cof[]);
	void polcof(float xa[], float ya[], int n, float cof[]);
	void poldiv(float u[], int n, float v[], int nv, float q[], float r[]);
	void polin2(float x1a[], float x2a[], float **ya, int m, int n,
				float x1, float x2, float *y, float *dy);
	void polint(float xa[], float ya[], int n, float x, float *y, float *dy);
	void powell(float p[], float **xi, int n, float ftol, int *iter, float *fret,
				float (*func)(float []));
	void predic(float data[], int ndata, float d[], int m, float future[], int nfut);
	float probks(float alam);
	void psdes(unsigned long *lword, unsigned long *irword);
	void pwt(float a[], unsigned long n, int isign);
	void pwtset(int n);
	float pythag(float a, float b);
	void pzextr(int iest, float xest, float yest[], float yz[], float dy[],
				int nv);
	float qgaus(float (*func)(float), float a, float b);
	void qrdcmp(float **a, int n, float *c, float *d, int *sing);
	float qromb(float (*func)(float), float a, float b);
	float qromo(float (*func)(float), float a, float b,
				float (*choose)(float (*)(float), float, float, int));
	void qroot(float p[], int n, float *b, float *c, float eps);
	void qrsolv(float **a, int n, float c[], float d[], float b[]);
	void qrupdt(float **r, float **qt, int n, float u[], float v[]);
	float qsimp(float (*func)(float), float a, float b);
	float qtrap(float (*func)(float), float a, float b);
	float quad3d(float (*func)(float, float, float), float x1, float x2);
	void quadct(float x, float y, float xx[], float yy[], unsigned long nn,
				float *fa, float *fb, float *fc, float *fd);
	void quadmx(float **a, int n);
	void quadvl(float x, float y, float *fa, float *fb, float *fc, float *fd);
	float ran0(long *idum);
	float ran1(long *idum);
	float ran2(long *idum);
	float ran3(long *idum);
	float ran4(long *idum);
	void rank(unsigned long n, unsigned long indx[], unsigned long irank[]);
	void ranpt(float pt[], float regn[], int n);
	void ratint(float xa[], float ya[], int n, float x, float *y, float *dy);
	void ratlsq(double (*fn)(double), double a, double b, int mm, int kk,
				double cof[], double *dev);
	double ratval(double x, double cof[], int mm, int kk);
	float rc(float x, float y);
	float rd(float x, float y, float z);
	void realft(float data[], unsigned long n, int isign);
	void rebin(float rc, int nd, float r[], float xin[], float xi[]);
	void red(int iz1, int iz2, int jz1, int jz2, int jm1, int jm2, int jmf,
			 int ic1, int jc1, int jcf, int kc, float ***c, float **s);
	void relax(double **u, double **rhs, int n);
	void relax2(double **u, double **rhs, int n);
	void resid(double **res, double **u, double **rhs, int n);
	float revcst(float x[], float y[], int iorder[], int ncity, int n[]);
	void reverse(int iorder[], int ncity, int n[]);
	float rf(float x, float y, float z);
	float rj(float x, float y, float z, float p);
	void rk4(float y[], float dydx[], int n, float x, float h, float yout[],
			 void (*derivs)(float, float [], float []));
	void rkck(float y[], float dydx[], int n, float x, float h,
			  float yout[], float yerr[], void (*derivs)(float, float [], float []));
	void rkdumb(float vstart[], int nvar, float x1, float x2, int nstep,
				void (*derivs)(float, float [], float []));
	void rkqs(float y[], float dydx[], int n, float *x,
			  float htry, float eps, float yscal[], float *hdid, float *hnext,
			  void (*derivs)(float, float [], float []));
	void rlft3(float ***data, float **speq, unsigned long nn1,
			   unsigned long nn2, unsigned long nn3, int isign);
	float rofunc(float b);
	void rotate(float **r, float **qt, int n, int i, float a, float b);
	void rsolv(float **a, int n, float d[], float b[]);
	void rstrct(double **uc, double **uf, int nc);
	float rtbis(float (*func)(float), float x1, float x2, float xacc);
	float rtflsp(float (*func)(float), float x1, float x2, float xacc);
	float rtnewt(void (*funcd)(float, float *, float *), float x1, float x2,
				 float xacc);
	float rtsafe(void (*funcd)(float, float *, float *), float x1, float x2,
				 float xacc);
	float rtsec(float (*func)(float), float x1, float x2, float xacc);
	void rzextr(int iest, float xest, float yest[], float yz[], float dy[], int nv);
	void savgol(float c[], int np, int nl, int nr, int ld, int m);
	void score(float xf, float y[], float f[]);
	void scrsho(float (*fx)(float));
	float nr_select(unsigned long k, unsigned long n, float arr[]);
	float selip(unsigned long k, unsigned long n, float arr[]);
	void shell(unsigned long n, float a[]);
	void shoot(int n, float v[], float f[]);
	void shootf(int n, float v[], float f[]);
	void simp1(float **a, int mm, int ll[], int nll, int iabf, int *kp,
			   float *bmax);
	void simp2(float **a, int n, int l2[], int nl2, int *ip, int kp, float *q1);
	void simp3(float **a, int i1, int k1, int ip, int kp);
	void simplx(float **a, int m, int n, int m1, int m2, int m3, int *icase,
				int izrov[], int iposv[]);
	void simpr(float y[], float dydx[], float dfdx[], float **dfdy,
			   int n, float xs, float htot, int nstep, float yout[],
			   void (*derivs)(float, float [], float []));
	void sinft(float y[], int n);
	void slvsm2(double **u, double **rhs);
	void slvsml(double **u, double **rhs);
	void sncndn(float uu, float emmc, float *sn, float *cn, float *dn);
	double snrm(unsigned long n, double sx[], int itol);
	void sobseq(int *n, float x[]);
	void solvde(int itmax, float conv, float slowc, float scalv[],
				int indexv[], int ne, int nb, int m, float **y, float ***c, float **s);
	void sor(double **a, double **b, double **c, double **d, double **e,
			 double **f, double **u, int jmax, double rjac);
	void sort(unsigned long n, float arr[]);
	void sort2(unsigned long n, float arr[], float brr[]);
	void sort3(unsigned long n, float ra[], float rb[], float rc[]);
	void spctrm(FILE *fp, float p[], int m, int k, int ovrlap);
	void spear(float data1[], float data2[], unsigned long n, float *d, float *zd,
			   float *probd, float *rs, float *probrs);
	void sphbes(int n, float x, float *sj, float *sy, float *sjp, float *syp);
	void splie2(float x1a[], float x2a[], float **ya, int m, int n, float **y2a);
	void splin2(float x1a[], float x2a[], float **ya, float **y2a, int m, int n,
				float x1, float x2, float *y);
	void spline(float x[], float y[], int n, float yp1, float ypn, float y2[]);
	void splint(float xa[], float ya[], float y2a[], int n, float x, float *y);
	void spread(float y, float yy[], unsigned long n, float x, int m);
	void sprsax(float sa[], unsigned long ija[], float x[], float b[],
				unsigned long n);
	void sprsin(float **a, int n, float thresh, unsigned long nmax, float sa[],
				unsigned long ija[]);
	void sprspm(float sa[], unsigned long ija[], float sb[], unsigned long ijb[],
				float sc[], unsigned long ijc[]);
	void sprstm(float sa[], unsigned long ija[], float sb[], unsigned long ijb[],
				float thresh, unsigned long nmax, float sc[], unsigned long ijc[]);
	void sprstp(float sa[], unsigned long ija[], float sb[], unsigned long ijb[]);
	void sprstx(float sa[], unsigned long ija[], float x[], float b[],
				unsigned long n);
	void stifbs(float y[], float dydx[], int nv, float *xx,
				float htry, float eps, float yscal[], float *hdid, float *hnext,
				void (*derivs)(float, float [], float []));
	void stiff(float y[], float dydx[], int n, float *x,
			   float htry, float eps, float yscal[], float *hdid, float *hnext,
			   void (*derivs)(float, float [], float []));
	void stoerm(float y[], float d2y[], int nv, float xs,
				float htot, int nstep, float yout[],
				void (*derivs)(float, float [], float []));
	void svbksb(float **u, float w[], float **v, int m, int n, float b[],
				float x[]);
	void svdcmp(float **a, int m, int n, float w[], float **v);
	void svdfit(float x[], float y[], float sig[], int ndata, float a[],
				int ma, float **u, float **v, float w[], float *chisq,
				void (*funcs)(float, float [], int));
	void svdvar(float **v, int ma, float w[], float **cvm);
	void toeplz(float r[], float x[], float y[], int n);
	void tptest(float data1[], float data2[], unsigned long n, float *t, float *prob);
	void tqli(float d[], float e[], int n, float **z);
	float trapzd(float (*func)(float), float a, float b, int n);
	void tred2(float **a, int n, float d[], float e[]);
	void tridag(float a[], float b[], float c[], float r[], float u[],
				unsigned long n);
	float trncst(float x[], float y[], int iorder[], int ncity, int n[]);
	void trnspt(int iorder[], int ncity, int n[]);
	void ttest(float data1[], unsigned long n1, float data2[], unsigned long n2,
			   float *t, float *prob);
	void tutest(float data1[], unsigned long n1, float data2[], unsigned long n2,
				float *t, float *prob);
	void twofft(float data1[], float data2[], float fft1[], float fft2[],
				unsigned long n);
	void vander(double x[], double w[], double q[], int n);
	void vegas(float regn[], int ndim, float (*fxn)(float [], float), int init,
			   unsigned long ncall, int itmx, int nprn, float *tgral, float *sd,
			   float *chi2a);
	void voltra(int n, int m, float t0, float h, float *t, float **f,
				float (*g)(int, float), float (*ak)(int, int, float, float));
	void wt1(float a[], unsigned long n, int isign,
			 void (*wtstep)(float [], unsigned long, int));
	void wtn(float a[], unsigned long nn[], int ndim, int isign,
			 void (*wtstep)(float [], unsigned long, int));
	void wwghts(float wghts[], int n, float h,
				void (*kermom)(double [], double ,int));
	int zbrac(float (*func)(float), float *x1, float *x2);
	void zbrak(float (*fx)(float), float x1, float x2, int n, float xb1[],
			   float xb2[], int *nb);
	float zbrent(float (*func)(float), float x1, float x2, float tol);
	void zrhqr(float a[], int m, float rtr[], float rti[]);
	float zriddr(float (*func)(float), float x1, float x2, float xacc);
	void zroots(fcomplex a[], int m, fcomplex roots[], int polish);

#else /* ANSI */
/* traditional - K&R */

	void addint();
	void airy();
	void amebsa();
	void amoeba();
	float amotry();
	float amotsa();
	void anneal();
	double anorm2();
	void arcmak();
	void arcode();
	void arcsum();
	void asolve();
	void atimes();
	void avevar();
	void balanc();
	void banbks();
	void bandec();
	void banmul();
	void bcucof();
	void bcuint();
	void beschb();
	float bessi();
	float bessi0();
	float bessi1();
	void bessik();
	float bessj();
	float bessj0();
	float bessj1();
	void bessjy();
	float bessk();
	float bessk0();
	float bessk1();
	float bessy();
	float bessy0();
	float bessy1();
	float beta();
	float betacf();
	float betai();
	float bico();
	void bksub();
	float bnldev();
	float brent();
	void broydn();
	void bsstep();
	void caldat();
	void chder();
	float chebev();
	void chebft();
	void chebpc();
	void chint();
	float chixy();
	void choldc();
	void cholsl();
	void chsone();
	void chstwo();
	void cisi();
	void cntab1();
	void cntab2();
	void convlv();
	void copy();
	void correl();
	void cosft();
	void cosft1();
	void cosft2();
	void covsrt();
	void crank();
	void cyclic();
	void daub4();
	float dawson();
	float dbrent();
	void ddpoly();
	int decchk();
	void derivs();
	float df1dim();
	void dfour1();
	void dfpmin();
	float dfridr();
	void dftcor();
	void dftint();
	void difeq();
	void dlinmin();
	double dpythag();
	void drealft();
	void dsprsax();
	void dsprstx();
	void dsvbksb();
	void dsvdcmp();
	void eclass();
	void eclazz();
	float ei();
	void eigsrt();
	float elle();
	float ellf();
	float ellpi();
	void elmhes();
	float erfcc();
	float erff();
	float erffc();
	void eulsum();
	float evlmem();
	float expdev();
	float expint();
	float f1();
	float f1dim();
	float f2();
	float f3();
	float factln();
	float factrl();
	void fasper();
	void fdjac();
	void fgauss();
	void fill0();
	void fit();
	void fitexy();
	void fixrts();
	void fleg();
	void flmoon();
	float fmin();
	void four1();
	void fourew();
	void fourfs();
	void fourn();
	void fpoly();
	void fred2();
	float fredin();
	void frenel();
	void frprmn();
	void ftest();
	float gamdev();
	float gammln();
	float gammp();
	float gammq();
	float gasdev();
	void gaucof();
	void gauher();
	void gaujac();
	void gaulag();
	void gauleg();
	void gaussj();
	void gcf();
	float golden();
	void gser();
	void hpsel();
	void hpsort();
	void hqr();
	void hufapp();
	void hufdec();
	void hufenc();
	void hufmak();
	void hunt();
	void hypdrv();
	fcomplex hypgeo();
	void hypser();
	unsigned short icrc();
	unsigned short icrc1();
	unsigned long igray();
	void iindexx();
	void indexx();
	void interp();
	int irbit1();
	int irbit2();
	void jacobi();
	void jacobn();
	long julday();
	void kendl1();
	void kendl2();
	void kermom();
	void ks2d1s();
	void ks2d2s();
	void ksone();
	void kstwo();
	void laguer();
	void lfit();
	void linbcg();
	void linmin();
	void lnsrch();
	void load();
	void load1();
	void load2();
	void locate();
	void lop();
	void lubksb();
	void ludcmp();
	void machar();
	void matadd();
	void matsub();
	void medfit();
	void memcof();
	int metrop();
	void mgfas();
	void mglin();
	float midexp();
	float midinf();
	float midpnt();
	float midsql();
	float midsqu();
	void miser();
	void mmid();
	void mnbrak();
	void mnewt();
	void moment();
	void mp2dfr();
	void mpadd();
	void mpdiv();
	void mpinv();
	void mplsh();
	void mpmov();
	void mpmul();
	void mpneg();
	void mppi();
	void mprove();
	void mpsad();
	void mpsdv();
	void mpsmu();
	void mpsqrt();
	void mpsub();
	void mrqcof();
	void mrqmin();
	void newt();
	void odeint();
	void orthog();
	void pade();
	void pccheb();
	void pcshft();
	void pearsn();
	void period();
	void piksr2();
	void piksrt();
	void pinvs();
	float plgndr();
	float poidev();
	void polcoe();
	void polcof();
	void poldiv();
	void polin2();
	void polint();
	void powell();
	void predic();
	float probks();
	void psdes();
	void pwt();
	void pwtset();
	float pythag();
	void pzextr();
	float qgaus();
	void qrdcmp();
	float qromb();
	float qromo();
	void qroot();
	void qrsolv();
	void qrupdt();
	float qsimp();
	float qtrap();
	float quad3d();
	void quadct();
	void quadmx();
	void quadvl();
	float ran0();
	float ran1();
	float ran2();
	float ran3();
	float ran4();
	void rank();
	void ranpt();
	void ratint();
	void ratlsq();
	double ratval();
	float rc();
	float rd();
	void realft();
	void rebin();
	void red();
	void relax();
	void relax2();
	void resid();
	float revcst();
	void reverse();
	float rf();
	float rj();
	void rk4();
	void rkck();
	void rkdumb();
	void rkqs();
	void rlft3();
	float rofunc();
	void rotate();
	void rsolv();
	void rstrct();
	float rtbis();
	float rtflsp();
	float rtnewt();
	float rtsafe();
	float rtsec();
	void rzextr();
	void savgol();
	void score();
	void scrsho();
	float nr_select();
	float selip();
	void shell();
	void shoot();
	void shootf();
	void simp1();
	void simp2();
	void simp3();
	void simplx();
	void simpr();
	void sinft();
	void slvsm2();
	void slvsml();
	void sncndn();
	double snrm();
	void sobseq();
	void solvde();
	void sor();
	void sort();
	void sort2();
	void sort3();
	void spctrm();
	void spear();
	void sphbes();
	void splie2();
	void splin2();
	void spline();
	void splint();
	void spread();
	void sprsax();
	void sprsin();
	void sprspm();
	void sprstm();
	void sprstp();
	void sprstx();
	void stifbs();
	void stiff();
	void stoerm();
	void svbksb();
	void svdcmp();
	void svdfit();
	void svdvar();
	void toeplz();
	void tptest();
	void tqli();
	float trapzd();
	void tred2();
	void tridag();
	float trncst();
	void trnspt();
	void ttest();
	void tutest();
	void twofft();
	void vander();
	void vegas();
	void voltra();
	void wt1();
	void wtn();
	void wwghts();
	int zbrac();
	void zbrak();
	float zbrent();
	void zrhqr();
	float zriddr();
	void zroots();

#endif /* ANSI */

#ifdef __cplusplus
}
#endif

#endif /* _NR_H_ */

